{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# COMPSCI 389: Homework 5\n",
    "\n",
    "**Assigned**: April 30, 2026. **Due**: May 7, 2026 at 1:00pm Eastern. **Note**: Submissions received after 1:00pm Eastern on May 14, 2026 will receive no credit.\n",
    "\n",
    "**Submitting**: Upload your submission on Gradescope as a `.pdf`. Converting to a PDF can be a complicated process, and so we encourage you to test this process well in advance of the submission deadlines. We recommend converting to HTML, opening the HTML file in a browser, and then printing or exporting to a PDF from your browser. We do not recommend directly converting to a PDF, since this requires installing xelatex. To convert to HTML in VSCode, press `ctrl+shift+p` and type `export`, and you should see an option to export to HTML.\n",
    "\n",
    "**Note**: Keep your `.ipynb` file, as we may request it directly (via email).\n",
    "\n",
    "**Note**: When converting to a PDF file, ensure that all of your code cells have been executed. The results of these executions *must* be included in your submitted PDF."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Note: Different Instructions\n",
    "\n",
    "Unlike past assignments, this one does not come with solutions. You should complete this assignment on your own without using any materials other than those posted on the course webpage. However, you may reference online documentation for Python or Jupyter notebooks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Overview\n",
    "\n",
    "In this assignment we will implement the MENACE algorithm and plot a **learning curve** that characterizes how it learns. Some code will be provided for you, but you will be asked to add some missing parts of the code. Specifically, you should add \"Step 8\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 1: Import Statements\n",
    "\n",
    "Let's begin with the import statements that we will use. You should not use any additional import statements without prior approval from the instructor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import time\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 2: Implementing Tic-Tac-Toe (Naughts and Crosses)\n",
    "\n",
    "In this section we implement tic-tac-toe. This code has been provided, but you are encouraged to look through it so that you are familiar with the details.\n",
    "\n",
    "We will represent the board as a $3 \\times 3$ matrix with values 'X', 'O', or ' ' (empty). First, let's write a function to print the board."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_board(board):\n",
    "    for row in board:\n",
    "        print(\" | \".join(row))\n",
    "        print(\"-\" * 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let's write a function to check for a winner. This function returns 'X', 'O', 'Draw', or None (game still in progress). It works by creating a tuple of tuples (array of arrays) `lines`. Each element of `lines` is an array of length 3 containing the pieces (X, Y, empty) along one possible line where a player could get three pieces in a row. Once this tuple of tuples has been created, it loops over `lines` to check whether any of these contain the same value (that isn't ' ', which denotes empty). If there are now winners yet, it checks whether there are any empty squares. If so, the game is not yet over. If there are no empty squares, the game is a draw."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_winner(board):\n",
    "    # Load lines with all of the sequences on the board where a player could get three in a row\n",
    "    lines = (\n",
    "        # Horizontal lines\n",
    "        board[0], board[1], board[2],\n",
    "        # Vertical lines\n",
    "        [board[0][0], board[1][0], board[2][0]], \n",
    "        [board[0][1], board[1][1], board[2][1]], \n",
    "        [board[0][2], board[1][2], board[2][2]],\n",
    "        # Diagonals\n",
    "        [board[0][0], board[1][1], board[2][2]], \n",
    "        [board[2][0], board[1][1], board[0][2]]\n",
    "    )\n",
    "\n",
    "    # Loop over all of these lines\n",
    "    for line in lines:\n",
    "        # Check whether all three elements in this line are the same, and not empty\n",
    "        if line[0] == line[1] == line[2] and line[0] != ' ':\n",
    "            # There is a winner! Return the winner, ('X' or 'O')\n",
    "            return line[0]\n",
    "    \n",
    "    # Check for a draw (no empty squares)\n",
    "    if all(all(cell != ' ' for cell in row) for row in board):\n",
    "        return 'Draw'\n",
    "    \n",
    "    # The game isn't over yet!\n",
    "    return None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let's write functions:\n",
    "- `valid_moves`: Returns a list of all empty spaces where plpayers can make a move. Each element of this list is an $(i,j)$ tuple.\n",
    "- `make_move`: Updates the board with the player's move if the chosen position is empty. It returns `True` on success and `False` on failure (we will use this for error checking).\n",
    "- `initialize_board`: Generates a $3 \\times 3$ tic-tac-toe board initialized with empty spaces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def valid_moves(board):\n",
    "    return [(i, j) for i in range(3) for j in range(3) if board[i][j] == ' ']\n",
    "\n",
    "def make_move(board, move, player):\n",
    "    i, j = move\n",
    "    if board[i][j] == ' ':\n",
    "        board[i][j] = player\n",
    "        return True\n",
    "    return False\n",
    "\n",
    "def initialize_board():\n",
    "    return [[' ' for _ in range(3)] for _ in range(3)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 3: Implementing Players\n",
    "\n",
    "We will create a class for \"players\". One player will be MENACE, another will select moves randomly. Below is the implementation of the base class. It has three functions:\n",
    "\n",
    "- `get_move`: Presents the player with a board and asks for a move. The `symbol` is an additional argument saying which symbol, X or O, the player is playing as.\n",
    "- `learn`: This is called at the end of a game and has the games result. The player can use this to change its policy. Like `get_move`, this function also takes `symbol` as an argument, telling the player which symbol it was playing as.\n",
    "- `reset`: This is used to reset the agent so that multiple trials can be run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Player:\n",
    "    def get_move(self, board, symbol):\n",
    "        raise NotImplementedError(\"This method should be overridden by subclasses\")\n",
    "    \n",
    "    def learn(self, result, symbol):\n",
    "        raise NotImplementedError(\"This method should be overridden by subclasses\")\n",
    "    \n",
    "    def reset(self):\n",
    "        raise NotImplementedError(\"This method should be overridden by subclasses\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is the `RandomPlayer` class, which always selects moves uniformly randomly from the legal moves."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RandomPlayer(Player):\n",
    "    def get_move(self, board, symbol):\n",
    "        moves = valid_moves(board)\n",
    "        return random.choice(moves)\n",
    "    \n",
    "    def learn(self, result, symbol):\n",
    "        pass  # Random player does not learn\n",
    "    \n",
    "    def reset(self):\n",
    "        pass  # No state to reset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 4: Playing a Game\n",
    "\n",
    "Next we provide code to play a game. This function takes as input two players (e.g., the `random_player` function that we wrote), and has the players play one game. It returns the winner, with the first player being 'X' and the second player being 'O'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def play_game(player1, player2):\n",
    "    # Start with blank initial board\n",
    "    board = initialize_board()\n",
    "\n",
    "    # Store the current and next player. These will be swapped after each turn\n",
    "    current_player, next_player = player1, player2\n",
    "\n",
    "    # Also store the current and next symbol (also swapper after each turn).\n",
    "    current_symbol, next_symbol = 'X', 'O'\n",
    "    \n",
    "    # Loop over time (moves)\n",
    "    while True:\n",
    "        # Query the current player for a move\n",
    "        move = current_player.get_move(board, current_symbol)\n",
    "\n",
    "        # Make the move\n",
    "        if not make_move(board, move, current_symbol):\n",
    "            # Handle illegal or failed moves. Print something to help with debugging this case!\n",
    "            print(f\"WARNING: Illegal move by {current_symbol}.\")\n",
    "            current_player.learn('Loss', current_symbol)\n",
    "            next_player.learn('Win', next_symbol)\n",
    "            return next_symbol  # Opponent wins if illegal move\n",
    "\n",
    "        # Check whether the game is over\n",
    "        winner = check_winner(board)\n",
    "        if winner:\n",
    "            # If we get here, the game is over. Call the \"learn\" functions\n",
    "            if winner == 'Draw':\n",
    "                player1.learn('Draw', 'X')\n",
    "                player2.learn('Draw', 'O')\n",
    "            else:\n",
    "                player1.learn('Win' if winner == 'X' else 'Loss', 'X')\n",
    "                player2.learn('Win' if winner == 'O' else 'Loss', 'O')\n",
    "            return winner\n",
    "        \n",
    "        # Swap players and symbols for the next turn\n",
    "        current_player, next_player = next_player, current_player\n",
    "        current_symbol, next_symbol = next_symbol, current_symbol"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 5: Running and Experiment\n",
    "\n",
    "Next we provide code to have two players play `games_per_trial` games against each other. Right now the players don't learn, but when we implement MENACE we expect it to learn during these games. However, playing this number of games might give different results if we ran it many times. To capture this, we repeat this process `num_trials` times, storing the results.\n",
    "\n",
    "That is, the players play `num_trials` sequences of `games_per_trial` against each other, and the outcomes of all games are stored.\n",
    "\n",
    "The results that are returned are *rewards* from the perspective of `player1`. The rewards are (again, from `player1`'s perspective):\n",
    "- Win: +3\n",
    "- Loss: -1\n",
    "- Draw: +1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_trials(num_trials, games_per_trial, player1, player2):\n",
    "    # Create a matrix where we will store the results. It has num_trials rows and games_per_trial cols\n",
    "    results_matrix = np.zeros((num_trials, games_per_trial))\n",
    "\n",
    "    # Loop over the trials\n",
    "    for trial in range(num_trials):\n",
    "        # Reset the players so they learn from scratch\n",
    "        player1.reset()\n",
    "        player2.reset()\n",
    "\n",
    "        # Loop over games in this trial\n",
    "        for game in range(games_per_trial):\n",
    "            # Have player1 go first for even trials and player2 go first for odd trials\n",
    "            if game % 2 == 0:\n",
    "                result = play_game(player1, player2)\n",
    "                reward = 3 if result == 'X' else 1 if result == 'Draw' else -1\n",
    "            else:\n",
    "                result = play_game(player2, player1)\n",
    "                reward = 3 if result == 'O' else 1 if result == 'Draw' else -1\n",
    "            \n",
    "            # Log the result as a reward value\n",
    "            results_matrix[trial, game] = reward\n",
    "    \n",
    "    # Return the computed results\n",
    "    return results_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 6: Plotting the Results\n",
    "\n",
    "Next, we provide code to plot the results. This will be a plot with the number of games played on the horizontal axis and the resulting reward on the vertical axis. We will average the results from the `num_trials` trials that are run, and will include standard-error error bars.\n",
    "\n",
    "**Note**: To reduce the number of points plotted, this plots a point ever 100 games. Each point reports the average reward over the last 100 games.\n",
    "\n",
    "**Note**: We also include a red dashed line at 1.0, which corresponds to roughly the value achieved when neither agent learns. MENACE should be able to improve upon this line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_learning_curve(results_matrix):\n",
    "    # Calculate the mean rewards and standard errors across trials for each game\n",
    "    mean_rewards = np.mean(results_matrix, axis=0)\n",
    "    standard_errors = np.std(results_matrix, axis=0) / np.sqrt(results_matrix.shape[0])\n",
    "    games = np.arange(1, results_matrix.shape[1] + 1)\n",
    "\n",
    "    # Averaging over intervals of 100 games\n",
    "    interval = 100\n",
    "    num_intervals = (len(mean_rewards) + interval - 1) // interval\n",
    "    averaged_means = []\n",
    "    averaged_errors = []\n",
    "    averaged_games = []\n",
    "\n",
    "    for i in range(num_intervals):\n",
    "        start_index = i * interval\n",
    "        end_index = min(start_index + interval, len(mean_rewards))\n",
    "        \n",
    "        # Calculate the mean of means and the mean of errors for the interval\n",
    "        interval_means = mean_rewards[start_index:end_index]\n",
    "        interval_errors = standard_errors[start_index:end_index]\n",
    "\n",
    "        averaged_means.append(np.mean(interval_means))\n",
    "        averaged_errors.append(np.mean(interval_errors))\n",
    "        averaged_games.append(np.mean(games[start_index:end_index]))\n",
    "\n",
    "    # Create the plot\n",
    "    plt.figure(figsize=(10, 6))\n",
    "    plt.plot(averaged_games, averaged_means, '-', label='Average Reward', color='blue')\n",
    "    plt.fill_between(averaged_games, np.array(averaged_means) - np.array(averaged_errors), np.array(averaged_means) + np.array(averaged_errors), color='lightblue', alpha=0.5)\n",
    "    plt.title('Learning Curve over Multiple Trials')\n",
    "    plt.xlabel('Game Number')\n",
    "    plt.ylabel('Average Reward')\n",
    "    plt.axhline(y=1, color='red', linestyle='--', label='No Learning Benchmark')\n",
    "    plt.ylim(-1.5, 3.5)\n",
    "    plt.legend()\n",
    "    plt.grid(True)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 7: Example Run\n",
    "\n",
    "Here is how we can run this code to obtain a **learning curve** for the random player playing against itself:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_trials = 100\n",
    "games_per_trial = 1000\n",
    "player1 = RandomPlayer()\n",
    "player2 = RandomPlayer()\n",
    "results = run_trials(num_trials, games_per_trial, player1, player2)\n",
    "plot_learning_curve(results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 8: Writing MENACE\n",
    "\n",
    "Finally, we're ready to implement MENACE! We will create a MenacePlayer class. The constructor takes an argument, `initial_beads`, that specifies how many beads (for each move) are placed in the matchboxes at the start. For this assignment, your task is to implement MENACE. Fill in the missing code below.\n",
    "\n",
    "<font color=\"red\">\n",
    "\n",
    "**NOTE:**\n",
    "You do **not** need to handle symmetric boards. That is, the real MENACE method treats two equivalent (but different) boards as being the same matchbox. For example, a board with only an X in the top-left and a board with only an X in the top-right are effectively the same, and a single matchbox could be used to handle both of these game states. Without accounting for these symmetric game states, there are roughly 20,000 possible boards in tic-tac-toe. Accounting for symmetries, the number of possible states can be reduced to just 304! Because our implementation does not account for these symmetries, it must effectively learn the right behavior for the \"same\" position many times independently. This will make our implementation much slower to learn than the real MENACE.\n",
    "\n",
    "</font>\n",
    "\n",
    "<font color=\"blue\">\n",
    "\n",
    "**NOTE:**\n",
    "You are encouraged to implement the variant of the MENACE algorithm described in class, although you are welcome to implement the full algorithm described in the paper \"Experiments on the mechanization of game-learning Part I. Characterization of the model and its parameters\" by Donald Michie.\n",
    "\n",
    "</font>\n",
    "\n",
    "Although your function specifications must remain unchanged, you are welcome to implement each function in any way you would like. We have provided one additional function that you may consider using (you do not need to use it and can delete it): `matchbox_key(self, board)`. This function maps a board to an integer that can be used as the key in a dictionary. Note that not all board states are possible, so this function doesn't map possible board states to consecutive integers. Rather, it ensures that a different integer is given for each possible board state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MenacePlayer:\n",
    "    def __init__(self, initial_beads):\n",
    "        self.initial_beads = initial_beads # The number of beads of each color to add at the start of each trial (here, and when reset is called)\n",
    "        ### TODO: ENTER YOUR CODE HERE\n",
    "\n",
    "    def reset(self):\n",
    "        ### TODO: ENTER YOUR CODE HERE. This function should completely reset the MenacePlayer so that it is as though it was a fresh new player\n",
    "        pass\n",
    "\n",
    "    def get_move(self, board, symbol):\n",
    "        ### TODO: ENTER YOUR CODE HERE. Note that you'll need to store the boards and moves until the learn function is called at the end of the game\n",
    "        ### NOTE: Our solution does not reference `symbol`.\n",
    "        ### NOTE: The code below is for selecting a random move and should be replaced\n",
    "        moves = valid_moves(board)\n",
    "        return random.choice(moves)\n",
    "\n",
    "    def learn(self, result, symbol):\n",
    "        ### TODO: ENTER YOUR CODE HERE.\n",
    "        ### NOTE: Our solution does not reference `symbol`.\n",
    "        ### NOTE: To avoid errors, either do not allow the last bead to ever be removed from a matchbox or ensure that having an empty matchbox is properly handled\n",
    "        ### NOTE: If you're storing a log of the game in get_move calls and using it here, don't forget to clear that log at the end of this function!\n",
    "        pass\n",
    "\n",
    "    ### TODO: YOU MAY DEFINE ADDITIONAL HELPER FUNCTIONS HERE.\n",
    "    def matchbox_key(self, board):\n",
    "        key = 0\n",
    "        multiplier = 1\n",
    "        for row in board:\n",
    "            for cell in row:\n",
    "                value = {'-': 0, 'X': 1, 'O': 2}.get(cell, 0)\n",
    "                key += value * multiplier\n",
    "                multiplier *= 3\n",
    "        return key  \n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 9: Results!\n",
    "\n",
    "Let's see how MENACE does against the random opponent! Run the code below with your complete MENACE implementation to produce the resulting learning curve. When working on your code and debugging, we recommend reducing the number of trials so that this runs faster. For your final submission, ensure that `num_trials = 100` and the resulting plot is included! On my desktop, my solution took 4 minutes to generate this final plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_trials = 10\n",
    "games_per_trial = 50000\n",
    "player1 = MenacePlayer(3)\n",
    "player2 = RandomPlayer()\n",
    "results = run_trials(num_trials, games_per_trial, player1, player2)\n",
    "plot_learning_curve(results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 11: Optional\n",
    "\n",
    "This section is not for credit and will not be evaluated. However, there are a few ways that you could modify your program for fun:\n",
    "\n",
    "1. Write your own fixed strategy as a new Player object, and see how MENACE fares against this fixed strategy. To make this easier, we included the `symbol` argument in `get_move`. This *can* be inferred from the game state, and so it's not necessary, but it simplifies this process.\n",
    "2. Modify your code to account for symmetric board positions, and see how much faster MENACE learns!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}